package com.yl.websocket;

import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.websocket.Session;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * websocket 客户端用户集
 *
 * @author ruoyi
 */
public class WebSocketUsers {
    /**
     * WebSocketUsers 日志控制器
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketUsers.class);

    /**
     * 用户集
     */
    private static Map<String, Session> USERS = new ConcurrentHashMap<String, Session>();


    /**
     * 房间号
     *
     * @author : y
     * @date :  2024/7/16 18:06
     **/
    private static Map<Long, Map<Long, Session>> conferenceMap = new ConcurrentHashMap<Long, Map<Long, Session>>();


    /**
     * 存储用户
     *
     * @param key     唯一键
     * @param session 用户信息
     */
    public static void put(Long key, Long conferenceId, Session session) {
        if (conferenceMap.containsKey(conferenceId)) {
            Map<Long, Session> map = conferenceMap.get(conferenceId);
            map.put(key, session);
            LOGGER.info("频道==={}，，目前在线人数=={}", conferenceId, map.size());
        } else {
            HashMap<Long, Session> hashMap = new HashMap<>();
            hashMap.put(key, session);
            conferenceMap.put(conferenceId, hashMap);
            LOGGER.info("频道==={}，，目前在线人数=={}", conferenceId, hashMap.size());
        }
    }

    /**
     * 存储用户
     *
     * @param key 唯一键
     */
    public static Session getOlineUserByUserId(Long key) {
        Session session = USERS.get(key + "");
        return session;
    }

    /**
     * 移出用户
     */
    public static boolean remove(Session session, Long conferenceId) {
        LOGGER.info("\n 正在移出用户 - {}", session);
        if (conferenceMap.containsKey(conferenceId)) {
            Map<Long, Session> map = conferenceMap.get(conferenceId);
            Long keyBySession = getKeyBySession(conferenceId, session);
            map.remove(keyBySession);
            LOGGER.info("目前频道中剩余人数==={}", map.size());
            if (map.size() == 0) {
                System.out.println("频道没人了 要去掉频道map");
                conferenceMap.remove(conferenceId);
            }
            boolean containsValue = map.containsValue(session);
            return containsValue;
        }
        return true;
    }


    /**
     * 获取在线用户列表
     * @return 返回用户集合
     */
    public static Map<Long, Session> getUsers(Long conferenceId) {
        if (conferenceMap == null) {
            System.out.println("在线用户列表为空");
            HashMap<Long, Session> hashMap = new HashMap<>();
            return hashMap;
        }
        if (conferenceMap.containsKey(conferenceId)) {
            Map<Long, Session> map = conferenceMap.get(conferenceId);
            System.out.println("在线用户列表不为空,人数" + map.size());
            return map;
        } else {
            System.out.println("在线用户列表为空");
            HashMap<Long, Session> hashMap = new HashMap<>();
            return hashMap;
        }
    }

    /**
     * 清空频道内全部人员
     *
     * @return 返回用户集合
     */
    public static Integer deleteUserList(Long conferenceId) {
        if (conferenceMap == null) {
            System.out.println("清空频道内全部人员 列表为空");
            HashMap<Long, Session> hashMap = new HashMap<>();
            return 0;
        }
        if (conferenceMap.containsKey(conferenceId)) {
            int num = 0;
            Map<Long, Session> map = conferenceMap.get(conferenceId);
            System.out.println("清空频道内全部人员,人数" + map.size());
            num = map.size();
            conferenceMap.remove(conferenceId);
            return num;
        }
        return 0;
    }

    /**
     * 清空频道内全部人员
     *
     * @return 返回用户集合
     */
    public static Boolean deleteUserByStudentId(Long conferenceId, Long studentId) {
        if (conferenceMap == null) {
            System.out.println("清空频道内全部人员 列表为空");
            HashMap<Long, Session> hashMap = new HashMap<>();
            return false;
        }
        if (conferenceMap.containsKey(conferenceId)) {
            Map<Long, Session> map = conferenceMap.get(conferenceId);
            map.remove(studentId);
            return true;
        }
        return false;
    }

    /**
     * 根据会议id 和session 删除
     *
     * @return 返回用户集合
     */
    public static Long getKeyBySession(Long conferenceId, Session session) {
        if (conferenceMap.containsKey(conferenceId)) {
            Map<Long, Session> map = conferenceMap.get(conferenceId);
            // 使用entrySet()方法获取Map中的所有键值对
            for (Map.Entry<Long, Session> entry : map.entrySet()) {
                // 打印键值对
                System.out.println(entry.getKey() + " => " + entry.getValue());
                if (entry.getValue().equals(session)) {
                    return entry.getKey();
                }
            }
            return null;
        } else {
            return null;
        }
    }

    /**
     * 群发消息文本消息
     *
     * @param message 消息内容
     */
    public static void sendAllToUsersByText(String message, Long conferenceId) {
        Map<Long, Session> stringSessionMap = conferenceMap.get(conferenceId);
        if (stringSessionMap == null) {
            LOGGER.info("未查询到在线人数===== conferenceId - {}", conferenceId);
            return;
        }
        LOGGER.info("群发消息=====人数 - {}", stringSessionMap.size());
        Collection<Session> values = stringSessionMap.values();
        for (Session value : values) {
            sendMessageToUserByText(value, message);
        }
    }

    /**
     * 发送文本消息
     * <p>
     * // * @param userName 自己的用户名
     *
     * @param message 消息内容
     */
    public static void sendMessageToUserByText(Session session, String message) {
        if (session != null) {
            try {
                session.getBasicRemote().sendText(message);
            } catch (IOException e) {
                LOGGER.error("\n[发送消息异常]", e);
            }
        } else {
            LOGGER.info("\n[你已离线]");
        }
    }
}
